#include "database.h"
#include "environment.h"
#include <QString>
#include <QTextStream>
#include <QFile>
#include <QSqlQuery>
#include <QMessageBox>
#include <QTextList>


//关于sqlite编码问题：

//因为Qt默认的是unicode的编号，所以不设定编码的话创建出来的sqlite数据库的编码就是unicode的
//所以一但我们存进行的数据就是unicode的，如果直接从拼写中文存放进去的话，必须用
//QString::fromLocal8Bit() 这个函数可将本地编号中文转换成相应的unicode编码中文，然后将它
//直接存放进数据库，就可以了


DataBase::DataBase(QObject *parent)
{
    mConnect = true;

}

/*******************************************
  功能：解析sql脚本文件，创建数据表
  ******************************************/
bool DataBase::createDB() const
{
    QString queryStr;
    QString filePath = SQLPATH;
    QFile file(filePath);
    if(!file.exists())
    {
        return false;
    }
    if(file.open(QFile::ReadOnly))
    {
        QTextStream stream(&file);
        queryStr = stream.readAll();
    }

    //因为sql脚本的格式是正常的sqlite操作，它通过分号";"来结束每一个操作，通过代码来进行时，sqlite不识别分号";"的，
    //所以必须将每一个操作进行分离
    QStringList list = queryStr.split(";");
#ifdef SLCD_DEBUG
    for(int i = 0; i < list.size(); i++)
    {
        QSqlQuery query;
        if(query.exec(list.at(i)))
            qDebug() << i  << " >>> query is true=============>";
        else
            qDebug() << i << "  >>> query is wrong!!!!!!!!!!!!!!" << list.at(i);
    }
#endif
    return true;
}

/*******************************************
  功能：打开数据库
  ******************************************/
bool DataBase::openDB(const QString &DBPath)
{
    bool isCreateTable = false;
    if(mConnect) {

        //查看是否有数据库文件，如果没有的话后面把创建相应的数据表
        QFile file(DBPath);
        if(!file.exists())
        {
            return false;
            isCreateTable = true;
        }


        //加载数据库
        mDB = new QSqlDatabase(QSqlDatabase::addDatabase("QSQLITE"));
        //设置数据数据库的名字，如果想在内存中读取数据库可以为:":memory"
        mDB->setDatabaseName(DBPath);

        if (!mDB->open()) {
            QMessageBox::critical(0, QObject::tr("Cannot open database"),
                                  QObject::tr("Unable to establish a database mConnection."
                                     ), QMessageBox::Cancel);
            return false;
        } else {
//            qDebug() << "open DB success";
            mDB->setPassword("123456");
        }

        //创建数据表，因为现在数据还没更新，所以暂时用已经建好的数据库
//        if (isCreateTable)
//        {
//            mDB->transaction();
//            this->createDB();
//            mDB->commit();
//        }


        mConnect = false;
        return true;
    }
    return true;
}

void DataBase::setResourcePath(const QString& resource)
{
    resourcePath = resource;
}

/*******************************************
  功能：关闭数据库
  ******************************************/
bool DataBase::closeDB()
{
//    qDebug() << "===============close mDB==================";
    if(mDB != NULL)
    {
        if(mDB->isOpen())
        {
            //name 存放数据库连接名字，关闭数据库不单只是将数据库关闭，还要将连接进行关闭
            QString name = mDB->connectionName();
            mDB->close();
            delete mDB;
            mDB = NULL;

            //关闭相应的数据库连接
            QSqlDatabase::removeDatabase(name);
        }
        mConnect = true;
    }
    return true;
}

/*******************************************
  功能：取得表 SLCD_T_Route 中的 RouteID
  参数：TISRouteCode 输入参数 编码
  ******************************************/
int DataBase::getRouteID(const QString &TISRouteCode, int trainDirectionID) const
{
    QSqlQuery query;
    int iRouteID;

    if(query.exec(QObject::tr("select RouteID from SLCD_T_Route where " \
                                   "TISRouteCode = \"%1\" and TrainDirectionID = %2") \
                  .arg(TISRouteCode).arg(trainDirectionID)))
    {
        if (query.next())
        {
            iRouteID = query.value(0).toInt();
        } else {
            iRouteID = -1;
        }
    } else {
//        qDebug() << "--------------getRouteID query error--------------";
        iRouteID = -1;
    }

    return iRouteID;
}

/*******************************************
  功能：取得表 SLCD_T_Staion 中的 StationID
  参数：TISRouteCode 输入的编码
  ******************************************/
int DataBase::getStationID(const QString &TISStationCode, const int routeID) const
{
    QSqlQuery query;
    int iStationID;

    if(query.exec(QObject::tr("select StationID from SLCD_T_Station where " \
                                  "TISStationCode = \"%1\"and RouteID = %2") \
                  .arg(TISStationCode).arg(routeID)))
    {
        if (query.next())
        {
            iStationID = query.value(0).toInt();
        } else {
            iStationID = -1;
        }
    } else {
        iStationID = -1;
    }

    return iStationID;
}

/*******************************************
  功能：取得表 SLCD_T_TrainDirection 中的 TrainDirectionID
  参数：trainDirectionDes 输入的
  ******************************************/
int DataBase::getTrainStatusID(const QString &trainStatusDes) const
{
    QSqlQuery query;
    int iTrainStatusID;

    if(query.exec(QObject::tr("select TrainStatusID from SLCD_D_TrainStatus where " \
                                  "TrainStatusDes = \"%1\"").arg(trainStatusDes)))
    {
        if (query.next())
        {
            iTrainStatusID = query.value(0).toInt();
        } else {
            iTrainStatusID = -1;
        }
    } else {
//        qDebug() << "--------------getTrainStatusID query error--------------";

        iTrainStatusID = -1;
    }

    return iTrainStatusID;
}

/*******************************************
  功能：取得列车方向ID
  参数：
  ******************************************/
int DataBase::getTrainDirectID(const QString &TISRouteCode) const
{
    QSqlQuery query;
    int trainDirectionID;

    if(query.exec(QObject::tr("select TrainDirectionID from SLCD_T_Route where " \
                                   "TISRouteCode = \"%1\"").arg(TISRouteCode)))
    {
        if (query.next())
        {
            trainDirectionID = query.value(0).toInt();
        } else {
            trainDirectionID = -1;
        }
    } else {
        trainDirectionID = -1;
    }

    return trainDirectionID;
}

int DataBase::getPositionInCarID(const QString& TISRouteCode) const
{
    return 0;
}

/*******************************************
  功能：取得表 SLCD_D_MainRelation 中的 PackageID和DefaultPackageID
  参数：结构体MainRelatIDStruct
  返回值：查询正确就返回true，否则返回false
  ******************************************/
bool DataBase::getPkgCustomPkgID(MainRelatIDStruct &mainRelatIDStruct) const
{

//    qDebug() << "mainRelatIDStruct+++>" << mainRelatIDStruct.routeID << mainRelatIDStruct.staionID << mainRelatIDStruct.trainDirectionID << mainRelatIDStruct.positionInCarID << mainRelatIDStruct.trainStatusID;
    QSqlQuery query;

    mainRelatIDStruct.usrPkgID = -1;
    mainRelatIDStruct.defaultPkgID = -1;

    if(query.exec(QObject::tr("select PackageID, Interval1, PackageID2, Interval2, PackageID3, Interval3, " \
                              "PackageID4, Interval4, PackageID5, Interval5 from SLCD_T_MainRelation " \
                              "where RouteID = %1 and StationID = %2 and TrainDirectionID = %3 " \
                              "and PositionInCarID = %4 and TrainStatusID = %5") \
                  .arg(mainRelatIDStruct.routeID).arg(mainRelatIDStruct.staionID) \
                  .arg(mainRelatIDStruct.trainDirectionID).arg(mainRelatIDStruct.positionInCarID) \
                  .arg(mainRelatIDStruct.trainStatusID)))
    {
        while(query.next())
        {
            PkgStruct pkgStruct;
            pkgStruct.pkgID = 0;
            pkgStruct.pkgID = query.value(0).toInt();
            pkgStruct.interval = query.value(1).toInt();
            if (pkgStruct.pkgID != 0)
                mainRelatIDStruct.usrPkgList.append(pkgStruct);
            pkgStruct.pkgID = 0;
            pkgStruct.interval = 0;

            pkgStruct.pkgID = query.value(2).toInt();
            pkgStruct.interval = query.value(3).toInt();
            if (pkgStruct.pkgID != 0)
                mainRelatIDStruct.usrPkgList.append(pkgStruct);
            pkgStruct.pkgID = 0;
            pkgStruct.interval = 0;

            pkgStruct.pkgID = query.value(4).toInt();
            pkgStruct.interval = query.value(5).toInt();
            if (pkgStruct.pkgID != 0)
                mainRelatIDStruct.usrPkgList.append(pkgStruct);
            pkgStruct.pkgID = 0;
            pkgStruct.interval = 0;

            pkgStruct.pkgID = query.value(6).toInt();
            pkgStruct.interval = query.value(7).toInt();
            if (pkgStruct.pkgID != 0)
                mainRelatIDStruct.usrPkgList.append(pkgStruct);
            pkgStruct.pkgID = 0;
            pkgStruct.interval = 0;

            pkgStruct.pkgID = query.value(8).toInt();
            pkgStruct.interval = query.value(9).toInt();
            if (pkgStruct.pkgID != 0)
                mainRelatIDStruct.usrPkgList.append(pkgStruct);
//            qDebug() << "mainRelatIDStruct==>" << mainRelatIDStruct.usrPkgList.count();
        }


        if (mainRelatIDStruct.usrPkgList.count() == 0)
            return false;
    } else
        return false;

    return true;
}

bool DataBase::getPkgDefaultPkgID(MainRelatIDStruct& mainRelatIDStruct) const
{
    //    qDebug() << "mainRelatIDStruct+++>" << mainRelatIDStruct.routeID << mainRelatIDStruct.staionID << mainRelatIDStruct.trainDirectionID << mainRelatIDStruct.positionInCarID << mainRelatIDStruct.trainStatusID;
    QSqlQuery query;

    mainRelatIDStruct.defaultPkgList.clear();

    if(query.exec(QObject::tr("select PackageID from SLCD_T_DefaultPackage " \
                              "where RouteID = %1") \
                  .arg(mainRelatIDStruct.routeID)))
    {
        while(query.next())
        {
            PkgStruct pkgStruct;
            pkgStruct.pkgID = 0;
            pkgStruct.interval = 0;
            pkgStruct.pkgID = query.value(0).toInt();
            if (pkgStruct.pkgID != 0)
                mainRelatIDStruct.defaultPkgList.append(pkgStruct);
        }

        if (mainRelatIDStruct.defaultPkgList.count() == 0)
            return false;
    } else
        return false;

    return true;
}
/*******************************************
  功能：取得表 SLCD_T_PackageRelation 中的 所有与packageID值相符合的列表
  参数：packageID：包编号
  返回： 返回的PkgRelatStruct的列表
  ******************************************/
QList<PkgRelatStruct> DataBase::getPkgRelatStructList(const int packageID) const
{
    QSqlQuery query;
    QList<PkgRelatStruct> PkgRelatStructList;
    PkgRelatStructList.clear();

    if(query.exec(QObject::tr("select LayoutID, PartitionID, ContentID, HolidayContentID " \
                              "from SLCD_T_PackageRelation where PackageID = %1").arg(packageID)))
    {
        while(query.next())
        {
            PkgRelatStruct PkgRelatStruct;
            PkgRelatStruct.pkgID = packageID;

            PkgRelatStruct.layoutID = query.value(0).toInt();
            PkgRelatStruct.partitionID = query.value(1).toInt();
            PkgRelatStruct.contentID = query.value(2).toInt();
            PkgRelatStruct.holidayContentID = query.value(3).toInt();

            PkgRelatStructList.append(PkgRelatStruct);
        }
    }

    return PkgRelatStructList;
}

/*******************************************
  功能：取得 节假日内容定义表 中的 所有与holidayContentID值相符合的数据
  参数：holidayContentID：节假日ID
  返回： 返回的 节假日描述结构体
  ******************************************/
HoliDesStruct DataBase::getHoliDesStruct(const int holidayContentID) const
{
    QSqlQuery query;
    HoliDesStruct holiDesStruct;

    holiDesStruct.holidayContentID = -1;
    holiDesStruct.holidayContentDes = "";
    holiDesStruct.playModeID = -1;

    if(query.exec(QObject::tr("select HolidayContentDes, PlayModeID from SLCD_T_HolidayContent " \
                              "where HolidayContentID = %1").arg(holidayContentID)))
    {
        if(query.next())
        {
            holiDesStruct.holidayContentID = holidayContentID;

            holiDesStruct.holidayContentDes = query.value(0).toString();
            holiDesStruct.playModeID = query.value(1).toInt();
        }
    }

    return holiDesStruct;
}

/*******************************************
  功能：取得 播放方式字典表 中 与playModeID值相符合的数据
  参数：playModeID:播放方式编号
  返回： 返回的 节假日播放方式结构体
  ******************************************/
HoliPlayModStruct DataBase::getHoliPlayModStruct(const int playModeID) const
{
    QSqlQuery query;
    HoliPlayModStruct holiPlayModStruct;

    holiPlayModStruct.playModelDES = "";
    holiPlayModStruct.playModelID = -1;


    holiPlayModStruct.playModelID = playModeID;

    if(query.exec(QObject::tr("select PlayModelDes from SLCD_D_PlayMode " \
                              "where PlayModeID = %1").arg(playModeID)))
    {
        if(query.next())
        {
            holiPlayModStruct.playModelID = playModeID;

            holiPlayModStruct.playModelDES = query.value(0).toString();
        } else {
//            qDebug() << "getHoliPlayModStruct can't find any data";
        }
    }
#ifdef SLCD_DEBUG
    else
        qDebug() << "--------------getHoliPlayModStruct query error--------------";
#endif

    return holiPlayModStruct;
}

HoliDesModStruct DataBase::getHoliDesModStruct(const int holidayContentID) const
{
    HoliDesModStruct holiDesModStruct;
    HoliDesStruct holiDesStruct;
    HoliPlayModStruct holiPlayModStruct;

    holiDesStruct = this->getHoliDesStruct(holidayContentID);
    holiPlayModStruct = this->getHoliPlayModStruct(holiDesStruct.playModeID);

    holiDesModStruct.holiDesStru = holiDesStruct;
    holiDesModStruct.holiPlayModStruct = holiPlayModStruct;

    return holiDesModStruct;

}


/*******************************************
  功能：取得表 SLCD_T_Layout 中的 所有与layoutID和partitionID值相符合的列表
  参数：layoutID:布局编号  partitionID：分区编号
  返回： 返回的PkgRelatStruct的列表
  ******************************************/
LayoutStruct DataBase::getLayoutStruct(const int layoutID, const int partitionID) const
{
    QSqlQuery query;
    LayoutStruct layoutStruct;

    layoutStruct.layoutID = -1;
    layoutStruct.partitionID = -1;
    layoutStruct.x = -1;
    layoutStruct.y = -1;
    layoutStruct.height = -1;
    layoutStruct.width = -1;

    if(query.exec(QObject::tr("select x, y, Height, Width from SLCD_T_Layout where LayoutID " \
                              "= %1 and PartitionID = %2").arg(layoutID).arg(partitionID)))
    {
        if (query.next())
        {
            layoutStruct.layoutID = layoutID;
            layoutStruct.partitionID = partitionID;

            layoutStruct.x = query.value(0).toInt();
            layoutStruct.y = query.value(1).toInt();
            layoutStruct.height = query.value(2).toInt();
            layoutStruct.width = query.value(3).toInt();
        }
    }
    return layoutStruct;
}

/*******************************************
  功能：取得表 节假日内容关系表 中的 所有与contentID和holiday值相符合的列表
  参数：ContentID:内容编号  holiday：节假日日期
  返回： 返回 节假日内容结构体 的列表
  ******************************************/
QList<ContentStruct> DataBase::getHoliCntStuctList(const int contentID, const QString &holiday) const
{

    QSqlQuery query;
    QList<ContentStruct> holidayContentStructList;
    holidayContentStructList.clear();

    //note:OrderID Order字段是有加双引号的，这一点要小心
    if(query.exec(QObject::tr("select OrderID, ContentTypeID, ContenFile, Duration from " \
                              "SLCD_T_HolidayContentRelation where ContentID = %1 and " \
                              "Holiday = \"%2\" order by OrderID").arg(contentID).arg(holiday)))
    {

        while(query.next())
        {
            ContentStruct holidayContentStruct;
            holidayContentStruct.contentID = contentID;
            holidayContentStruct.holiday = holiday;

            holidayContentStruct.order = query.value(0).toInt();
            holidayContentStruct.contentTypeID = query.value(1).toInt();
            holidayContentStruct.contentFile = resourcePath + "/" + query.value(2).toString();
            holidayContentStruct.duration = query.value(3).toInt();
            holidayContentStruct.isHolidayContent = true;

            holidayContentStructList.append(holidayContentStruct);
        }
    }
#ifdef SLCD_DEBUG
    else
        qDebug() << "--------------getHoliCntStuctList query error--------------";
#endif
    return holidayContentStructList;
}


/*******************************************
  功能：从3个表中取出 节假日信息结构体
  参数：ContentID:内容编号  holiday：节假日日期
  返回： 返回 节假日信息结构体
  ******************************************/
QList<HoliInfoStruct> DataBase::getHoliInfoStructList(const int contentID, const QString &holiday) const
{
    QList<HoliInfoStruct> holidayInfoStructList;
    QList<ContentStruct> holidayContentStructList;

    HoliInfoStruct holidayInfoStruct;
    HoliDesModStruct holidayDesModStruct;
    ContentStruct contentStruct;

    holidayContentStructList = this->getHoliCntStuctList(contentID, holiday);
    holidayInfoStructList.clear();

    for(int i = 0; i < holidayContentStructList.count(); i++)
    {
        contentStruct = holidayContentStructList.at(i);
        holidayDesModStruct = this->getHoliDesModStruct(contentStruct.contentID);

        holidayInfoStruct.holiDesModStruct = holidayDesModStruct;
        holidayInfoStruct.cntStruct = contentStruct;

        //节假日无无限播放功能
        holidayInfoStruct.cntStruct.isUnlimited = false;

        holidayInfoStructList.append(holidayInfoStruct);



    }
    return holidayInfoStructList;
}

/*******************************************
  功能：内容定义表 中取出 自定义内容描述结构体
  参数：ContentID:内容编号
  返回： 返回 自定义内容描述结构体
  ******************************************/
UsrCntDesStruct DataBase::getUsrCntDesStruct(const int contentID) const
{
    QSqlQuery query;
    UsrCntDesStruct usrCntDesStruct;

    usrCntDesStruct.contentID = -1;
    usrCntDesStruct.ContentDes = "";
    usrCntDesStruct.repeatTimes = -1;


    if(query.exec(QObject::tr("select ContentDes, RepeatTimes from SLCD_T_Content where ContentID " \
                              "= %1").arg(contentID)))
    {
        if (query.next())
        {
            usrCntDesStruct.contentID = contentID;

            usrCntDesStruct.ContentDes = query.value(0).toString();
            usrCntDesStruct.repeatTimes = query.value(1).toInt();
        }
    }

    return usrCntDesStruct;
}

/*******************************************
  功能：内容类型字典表 中取出 自定义内容播放类型结构体
  参数：ContentID:内容编号
  返回： 返回 自定义内容播放类型结构体
  ******************************************/
UsrCntTypeStruct DataBase::getUsrCntTypeStruct(const int cntTypeID) const
{
    QSqlQuery query;
    UsrCntTypeStruct usrCntTypeStruct;

    usrCntTypeStruct.contentTypeID = -1;
    usrCntTypeStruct.contentTypeDes = "";


    if (query.exec(QObject::tr("select ContentTypeDes from SLCD_D_ContentType where ContentTypeID " \
                              "= %1").arg(cntTypeID)))
    {
        if (query.next())
        {
            usrCntTypeStruct.contentTypeID = cntTypeID;
            usrCntTypeStruct.contentTypeDes = query.value(0).toString();
        }
    }
#ifdef SLCD_DEBUG
    else
        qDebug() << "============getUsrCntTypeStruct error==================";
#endif
    return usrCntTypeStruct;
}

/*******************************************
  功能：内容类型字典表 中取出 自定义内容播放类型结构体
  参数：ContentID:内容编号
  返回： 返回 自定义内容播放类型结构体
  ******************************************/
QList<ContentStruct> DataBase::getUsrCntStructList(const int contentID) const
{
    QSqlQuery query;
    QList<ContentStruct> usrCntStructList;

    ContentStruct usrCntStruct;

    usrCntStructList.clear();

    //note:OrderID Order字段是有加双引号的，这一点要小心
    if(query.exec(QObject::tr("select OrderID, ContentTypeID, ContenFile, Duration, RepeatFlag from " \
                              "SLCD_T_ContentRelation where ContentID = %1 order by OrderID").arg(contentID)))
    {

        while(query.next())
        {
            usrCntStruct.contentID = contentID;

//            qDebug() << "query" << query.value(2).toString();
            usrCntStruct.order = query.value(0).toInt();
            usrCntStruct.contentTypeID = query.value(1).toInt();
            usrCntStruct.contentFile = resourcePath + query.value(2).toString();
         //   qDebug() << "usrCntStruct===>" << usrCntStruct.contentFile;
            usrCntStruct.duration = query.value(3).toInt();
            usrCntStruct.repeatFlag = query.value(4).toInt();

            usrCntStruct.isHolidayContent = false;
            usrCntStructList.append(usrCntStruct);
        }
    }



    return usrCntStructList;
}

/*******************************************
  功能：从3个表中取出 自定义播放内容信息结构体
  参数：ContentID:内容编号
  返回： 返回 自定义播放内容信息结构体
  ******************************************/
QList<UsrInfoStru> DataBase::getUsrInfoStruList(const int contentID) const
{
    QList<UsrInfoStru> usrInfoStructList;
    QList<ContentStruct> usrCntStructList;

    UsrInfoStru usrInfoStruct;
    UsrCntDesStruct usrCntDesStruct;       //自定义内容描述结构体
    ContentStruct usrCntStruct;               //内容结构体
    UsrCntTypeStruct usrCntTypeStruct;     //自定义播放内容信息结构体



    usrCntStructList = this->getUsrCntStructList(contentID);

    for(int i = 0; i < usrCntStructList.count(); i++)
    {
        usrCntStruct = usrCntStructList.at(i);
        usrCntDesStruct = this->getUsrCntDesStruct(usrCntStruct.contentID);
        usrCntTypeStruct = this->getUsrCntTypeStruct(usrCntStruct.contentTypeID);

        usrInfoStruct.cntStruct = usrCntStruct;
        usrInfoStruct.usrCntDesStruct = usrCntDesStruct;
        usrInfoStruct.usrCntTypeStruct = usrCntTypeStruct;

//        qDebug() << "usrInfoStruct" << usrInfoStruct.cntStruct.contentFile << usrInfoStruct.cntStruct.repeatFlag << usrInfoStruct.usrCntDesStruct.repeatTimes;
        //当循环标志不为0时，而且一开始循环次数上为0，则证明它是无限循环播放的
        if (usrInfoStruct.cntStruct.repeatFlag != 0 && usrInfoStruct.usrCntDesStruct.repeatTimes == 0)
        {
            usrInfoStruct.cntStruct.isUnlimited = true;
        } else{
            usrInfoStruct.cntStruct.isUnlimited = false;
        }

        usrInfoStructList.append(usrInfoStruct);
    }

    return usrInfoStructList;
}



/***************************************************************

                        数据库添加数据接口

 **************************************************************/


/*****************  代换或者更新一条数据接口  *********************/

/*******************************************
  功能：在 SLCD_T_Station表 代换或者插入一行数据
  参数：要代换或者插入的一行数据 stationStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineStationTable(const StationStruct& stationStruct) const
{
    StationStruct staStru = stationStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_Station (StationID, StationName, TISStationCode, RouteID) values " \
                  "(%1, \"%2\", \"%3\", %4)").arg(staStru.stationID).arg(staStru.stationName) \
                  .arg(staStru.TISStationCode).arg(staStru.routeID)))
    {
        return true;
    } else {
        return false;
    }
}


/*******************************************
  功能：在 SLCD_T_Route 代换或者插入一行数据
  参数：要代换或者插入的一行数据 routeStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineRouteTable(const RouteStruct& routeStruct) const
{
    RouteStruct routeStru = routeStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_Route (RouteID, RouteName, TISRouteCode) values " \
                  "(%1, \"%2\", \"%3\")").arg(routeStru.routeID).arg(routeStruct.routeName) \
                   .arg(routeStru.TISRouteCode)))
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_D_TrainStatus 代换或者插入一行数据
  参数：要代换或者插入的一行数据 trainStatusStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineTrainTable(const TrainStatusStruct &trainStatusStruct) const
{
    TrainStatusStruct trainStatusStru = trainStatusStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_D_TrainStatus(TrainStatusID, TrainStatusDes) values " \
                               "(%1, \"%2\")").arg(trainStatusStru.trainStatusID) \
                   .arg(trainStatusStru.trainStatusDes)))
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_D_PositionInCar 代换或者插入一行数据
  参数：要代换或者插入的一行数据 posIncarStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLinePositionInCarTable(const PosInCarStruct& posIncarStruct) const
{
    PosInCarStruct posInCarStru = posIncarStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_D_PositionInCar(PositionInCarID, PositionInCarDes) " \
                               "values (%1, \"%2\")").arg(posInCarStru.positionID) \
                   .arg(posInCarStru.positionDes)))
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_MainRelation 代换或者插入一行数据
  参数：要代换或者插入的一行数据 mainRelatIDStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineMainRelatTable(const MainRelatIDStruct &mainRelatIDStruct) const
{
    MainRelatIDStruct mainRelatIDStru = mainRelatIDStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_MainRelation (RouteID ,StationID " \
                               ",TrainDirectionID, PositionInCarID, TrainStatusID, PackageID,"
                               "DefaultPackageID) values (%1, %2, %3, %4, %5, %6, %7)") \
                   .arg(mainRelatIDStru.routeID).arg(mainRelatIDStru.staionID) \
                   .arg(mainRelatIDStru.trainDirectionID).arg(mainRelatIDStru.positionInCarID) \
                   .arg(mainRelatIDStru.trainStatusID).arg(mainRelatIDStru.usrPkgID) \
                   .arg(mainRelatIDStru.defaultPkgID)))

    {
        return true;
    } else {
        return false;
    }
}


/*******************************************
  功能：在 SLCD_T_PackageRelation 代换或者插入一行数据
  参数：要代换或者插入的一行数据 PkgRelatStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLinePkgRelationTable(const PkgRelatStruct& pkgRelatStruct) const
{
    PkgRelatStruct pkgRelaStru = pkgRelatStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_PackageRelation(PackageID, LayoutID, " \
                               "PartitionID, ContentID, HolidayContentID) values (%1, %2, " \
                               "%3, %4, %5)") \
                   .arg(pkgRelaStru.pkgID).arg(pkgRelaStru.layoutID).arg(pkgRelaStru.partitionID) \
                   .arg(pkgRelaStru.contentID).arg(pkgRelaStru.holidayContentID)))
    {
        return true;
    } else {
        return false;
    }
}



/*******************************************
  功能：在 SLCD_T_Package 代换或者插入一行数据
  参数：要代换或者插入的一行数据 pkgDesStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLinePkgDesTable(const PkgDesStruct& pkgDesStruct) const
{
    PkgDesStruct pkgDesStru = pkgDesStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_Package(PackageID, PackageDes) values " \
                              "(%1, \"%2\")").arg(pkgDesStru.pkgID).arg(pkgDesStru.pkgDes)))
    {
        return true;
    } else {
        return false;
    }

}

/*******************************************
  功能：在 SLCD_T_Layout 代换或者插入一行数据
  参数：要代换或者插入的一行数据 layoutStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineLayoutTable(const LayoutStruct& layoutStruct) const
{
    LayoutStruct layoutStru = layoutStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_Layout(LayoutID, PartitionID, x, y, " \
                               "Height, Width) values (%1, %2, %3, %4, %5, %6)") \
                   .arg(layoutStru.layoutID).arg(layoutStru.partitionID).arg(layoutStru.x) \
                   .arg(layoutStru.y).arg(layoutStru.height).arg(layoutStru.width)))
    {
        return true;
    } else {
        return false;
    }

}

/*******************************************
  功能：在 SLCD_T_HolidayContentRelation 代换或者插入一行数据
  参数：要代换或者插入的一行数据 holidayCntStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineHoliCntRelatTable(const ContentStruct& holidayCntStruct) const
{
    ContentStruct holiCntStru = holidayCntStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_HolidayContentRelation(ContentID, Holiday, " \
                               "OrderID, ContentTypeID, ContenFile, Duration) values " \
                               "(%1, \"%2\", %3, %4, \"%5\", %6)") \
                   .arg(holiCntStru.contentID).arg(holiCntStru.holiday).arg(holiCntStru.order) \
                   .arg(holiCntStru.contentTypeID).arg(holiCntStru.contentFile) \
                   .arg(holiCntStru.duration)))
    {
        return true;
    } else {
        return false;
    }

}

/*******************************************
  功能：在 SLCD_T_HolidayContent 代换或者插入一行数据
  参数：要代换或者插入的一行数据 holiDesStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineHoliCntDesTable(const HoliDesStruct& holiDesStruct) const
{
    HoliDesStruct holiDesStru = holiDesStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_HolidayContent(HolidayContentID, " \
                               "HolidayContentDes, PlayModeID) values (%1, \"%2\", %3)") \
                   .arg(holiDesStru.holidayContentID).arg(holiDesStru.holidayContentDes) \
                   .arg(holiDesStru.playModeID)))
    {
        return true;
    } else {
        return false;
    }

}

/*******************************************
  功能：在 SLCD_D_PlayMode 代换或者插入一行数据
  参数：要代换或者插入的一行数据 holiPlayModStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLinePlayModeTable(const HoliPlayModStruct& holiPlayModStruct) const
{
    HoliPlayModStruct playModeStru = holiPlayModStruct;

    QSqlQuery query;


    if (query.exec(QObject::tr("replace into SLCD_D_PlayMode(PlayModeID, PlayModelDes) "
                               "values (%1, \"%2\")").arg(playModeStru.playModelID) \
                   .arg(playModeStru.playModelDES)))
    {
        return true;
    } else {
        return false;
    }

}

/*******************************************
  功能：在 SLCD_T_ContentRelation 代换或者插入一行数据
  参数：要代换或者插入的一行数据 usrContStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineUsrCntRelatTable(const ContentStruct& usrContentStruct) const
{
    ContentStruct usrCntStruct = usrContentStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_ContentRelation(ContentID, OrderID, " \
                               "ContentTypeID, ContenFile, Duration, RepeatFlag) values " \
                               "(%1, %2, %3, \"%4\", %5, %6)").arg(usrCntStruct.contentID) \
                   .arg(usrCntStruct.order).arg(usrCntStruct.contentTypeID).arg(usrCntStruct.contentFile) \
                   .arg(usrCntStruct.duration).arg(usrCntStruct.repeatFlag)))
    {
        return true;
    } else {
        return false;
    }

}

/*******************************************
  功能：在 SLCD_T_Content 代换或者插入一行数据
  参数：要代换或者插入的一行数据 usrCntDesStruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineUsrCntDesTable(const UsrCntDesStruct& usrCntDesStruct) const
{
    UsrCntDesStruct usrCntDesStru = usrCntDesStruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_T_Content(ContentID, ContentDes, " \
                               "RepeatTimes) values (%1, \"%2\", %3)") \
                   .arg(usrCntDesStru.contentID).arg(usrCntDesStru.ContentDes) \
                   .arg(usrCntDesStru.repeatTimes)))
    {
        return true;
    } else {
        return false;
    }

}
/*******************************************
  功能：在 SLCD_D_ContentType 代换或者插入一行数据
  参数：要代换或者插入的一行数据 usrCntTypestruct
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceLineUsrCntTypeTable(const UsrCntTypeStruct& usrCntTypestruct) const
{
    UsrCntTypeStruct usrCntTypeStru = usrCntTypestruct;

    QSqlQuery query;

    if (query.exec(QObject::tr("replace into SLCD_D_ContentType(ContentTypeID, ContentTypeDes) " \
                               "values (%1, \"%2\")").arg(usrCntTypeStru.contentTypeID) \
                   .arg(usrCntTypeStru.contentTypeDes)))
    {
        return true;
    } else {
        return false;
    }

}

/*****************  代换或者更新多条数据接口  *********************/


/*******************************************
  功能：在 SLCD_T_Station 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 stationStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListStationTable(const QList<StationStruct>& stationStructList) const
{
    int i;
    StationStruct stationStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < stationStructList.count(); i++)
    {
        stationStruct = stationStructList.at(i);

        this->replaceLineStationTable(stationStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;

}

/*******************************************
  功能：在 SLCD_T_Route 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 routeStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListRouteTable(const QList<RouteStruct>& routeStructList) const
{
    int i;
    RouteStruct routeStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < routeStructList.count(); i++)
    {
        routeStruct = routeStructList.at(i);

        this->replaceLineRouteTable(routeStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;

}

/*******************************************
  功能：在 SLCD_D_TrainStatus 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 trainStatusStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListTrainTable(const QList<TrainStatusStruct>& trainStatusStructList) const
{
    int i;
    TrainStatusStruct trainStatusStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < trainStatusStructList.count(); i++)
    {
        trainStatusStruct = trainStatusStructList.at(i);

        this->replaceLineTrainTable(trainStatusStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;

}

/*******************************************
  功能：在 SLCD_D_PositionInCar 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 posIncarStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListPositionInCarTable(const QList<PosInCarStruct>& posIncarStructList) const
{
    int i;
    PosInCarStruct posInCarStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < posIncarStructList.count(); i++)
    {
        posInCarStruct = posIncarStructList.at(i);

        this->replaceLinePositionInCarTable(posInCarStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;

}

/*******************************************
  功能：在 SLCD_T_MainRelation 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 mainRelatIDStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListMainRelatTable(const QList<MainRelatIDStruct> &mainRelatIDStructList) const
{
    int i;
    MainRelatIDStruct mainRelatIDStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < mainRelatIDStructList.count(); i++)
    {
        mainRelatIDStruct = mainRelatIDStructList.at(i);

        this->replaceLineMainRelatTable(mainRelatIDStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;

}
/*******************************************
  功能：在 SLCD_T_PackageRelation 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 PkgRelatStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListPkgRelationTable(const QList<PkgRelatStruct>& pkgRelatStructList)
{
    int i;
    PkgRelatStruct pkgRelatStru;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < pkgRelatStructList.count(); i++)
    {
        pkgRelatStru = pkgRelatStructList.at(i);

        this->replaceLinePkgRelationTable(pkgRelatStru);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_T_Package 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 pkgDesStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListPkgDesTable(const QList<PkgDesStruct>& pkgDesStructList) const
{
    int i;
    PkgDesStruct pkgDesStru;

    mDB->transaction();

    for(i = 0; i < pkgDesStructList.count(); i++)
    {
        pkgDesStru = pkgDesStructList.at(i);

        if (!this->replaceLinePkgDesTable(pkgDesStru))
            return false;
    }

    mDB->commit();

    return true;

}

/*******************************************
  功能：在 SLCD_T_Layout 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 layoutStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListLayoutTable(const QList<LayoutStruct>& layoutStructList) const
{
    int i;
    LayoutStruct layoutStru;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < layoutStructList.count(); i++)
    {
        layoutStru = layoutStructList.at(i);

        this->replaceLineLayoutTable(layoutStru);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_T_HolidayContent 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 holiDesStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListHoliCntTable(const QList<HoliDesStruct>& holiDesStructList) const
{
    int i;
    HoliDesStruct holiDesStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < holiDesStructList.count(); i++)
    {
        holiDesStruct = holiDesStructList.at(i);

        this->replaceLineHoliCntDesTable(holiDesStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_T_HolidayContentRelation 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 holidayCntStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListHoliCntDesRelatTable(const QList<ContentStruct>& holidayCntStructList) const
{
    int i;
    ContentStruct holiCntStru;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < holidayCntStructList.count(); i++)
    {
        holiCntStru = holidayCntStructList.at(i);

        this->replaceLineHoliCntRelatTable(holiCntStru);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_D_PlayMode 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 holiPlayModStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListplayModeTable(const QList<HoliPlayModStruct>& holiPlayModStructList) const
{
    int i;
    HoliPlayModStruct holiPlayModeStru;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < holiPlayModStructList.count(); i++)
    {
        holiPlayModeStru = holiPlayModStructList.at(i);

        this->replaceLinePlayModeTable(holiPlayModeStru);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_T_ContentRelation 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 usrContStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListUsrCntRelatTable(const QList<ContentStruct>& usrContStructList) const
{
    int i;
    ContentStruct usrCntStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < usrContStructList.count(); i++)
    {
        usrCntStruct = usrContStructList.at(i);

        this->replaceLineUsrCntRelatTable(usrCntStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_T_Content 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 usrCntDesStructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListUsrCntDesTable(const QList<UsrCntDesStruct>& usrCntDesStructList) const
{
    int i;
    UsrCntDesStruct usrCntDesStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < usrCntDesStructList.count(); i++)
    {
        usrCntDesStruct = usrCntDesStructList.at(i);

        this->replaceLineUsrCntDesTable(usrCntDesStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}

/*******************************************
  功能：在 SLCD_D_ContentType 代换或者插入多行数据
  参数：要代换或者插入的多行数据列表 usrCntTypestructList
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::replaceListUsrCntTypeTable(const QList<UsrCntTypeStruct>& usrCntTypestructList) const
{
    int i;
    UsrCntTypeStruct usrCntTypeStruct;

    //如果想要一次性插入很多条事件，此时你必须使用sqlite的业务机制
    //它会先将你的所有记录一次性提交，不用你每提交一条记录打开一次表
    mDB->transaction();

    for(i = 0; i < usrCntTypestructList.count(); i++)
    {
        usrCntTypeStruct = usrCntTypestructList.at(i);

        this->replaceLineUsrCntTypeTable(usrCntTypeStruct);
    }

    //提交所有的记录
    mDB->commit();

    return true;
}


/******* 删除数据接口 *******/


/*******************************************
  功能：在 SLCD_T_Station 删除 StationID 中等于 stationID的数据
  参数：stationID 要删除的 StationID 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesStationTable(const int stationID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_Station where StationID = %1").arg(stationID)))
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_Station 删除 RouteID 中等于 routeID 的数据
  参数：routeID  要删除的 RouteID 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesRouteTable(const int routeID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_Route where RouteID = %1").arg(routeID)))
    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_PositionInCar 删除 PositionInCar 中等于 posInCarID 的数据
  参数：posInCarID: 要删除的 PositionInCar 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesPosInCarTable(const int posInCarID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_PositionInCar where PositionInCar = %1") \
                   .arg(posInCarID)))
    {
        return true;
    } else {
        return false;
    }
}


/*******************************************
  功能：在 SLCD_T_PositionInCar 删除 PositionInCar 中等于 posInCarID 的数据
  参数： 要删除的 PositionInCar 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesMainRelatTable(const MainRelatIDStruct& mainRelatIDStruct) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_MainRelation where RouteID = %1 and StationID" \
                               "= %2 and TrainDirectionID = %3 and PositionInCarID = %4 " \
                               "and TrainStatusID = %5") \
        .arg(mainRelatIDStruct.routeID).arg(mainRelatIDStruct.staionID) \
        .arg(mainRelatIDStruct.trainDirectionID).arg(mainRelatIDStruct.positionInCarID) \
        .arg(mainRelatIDStruct.trainStatusID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_PackageRelation 删除 PackageID 中等于 packageID 的数据
  参数： 要删除的 packageID 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesPkgRelatTable(const int packageID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_PackageRelation where PackageID = %1") \
        .arg(packageID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_Package 删除 PackageID 中等于 packageID 的数据
  参数： 要删除的 packageID 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesPkgDesTable(const int packageID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_Package where PackageID = %1") \
        .arg(packageID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_Layout 删除 LayoutID 中等于 layoutID 的数据
  参数： 要删除的 layoutID 值
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesLayoutTable(const int layoutID, const int partitionID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_Layout where layoutID = %1 " \
                   "and PartitionID = %2").arg(layoutID).arg(partitionID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_HolidayContentRelation 删除和 参数 一样的行
  参数： contentID：内容ID, holiday：日期
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesHoliCntRelatTable(const int contentID, const QString& holiday) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_HolidayContentRelation where ContentID = %1 " \
                   "and Holiday = \"%2\"").arg(contentID).arg(holiday)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_HolidayContent 删除和 参数 一样的行
  参数： holidayContentID:内容ID号
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesHoliCntDesTable(const int holidayContentID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_HolidayContent where HolidayContentID = %1") \
                   .arg(holidayContentID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_HolidayContent 删除和 参数 一样的行
  参数： playModeID:播放方式ID
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesPlayModeTable(const int playModeID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_D_PlayMode where PlayModeID = %1") \
                   .arg(playModeID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_D_ContentRelation 删除和 参数 一样的行
  参数： contentID:内容ID
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesUsrCntRelatTable(const int contentID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_ContentRelation where ContentID = %1") \
                   .arg(contentID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_Content 删除和 参数 一样的行
  参数： contentID:内容ID
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesUsrCntDesTable(const int contentID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_T_Content where ContentID = %1") \
                   .arg(contentID)))

    {
        return true;
    } else {
        return false;
    }
}

/*******************************************
  功能：在 SLCD_T_ContentType 删除和 参数 一样的行
  参数： contentTypeID:内容ID
  返回值: 正确代换或者插入则返回ture 错误返回false
  ******************************************/
bool DataBase::delLinesUsrCntTypeTable(const int contentTypeID) const
{
    QSqlQuery query;


    if (query.exec(QObject::tr("delete from SLCD_D_ContentType where ContentTypeID = %1") \
                   .arg(contentTypeID)))

    {
        return true;
    } else {
        return false;
    }
}

bool DataBase::deletePkgTabelData()
{
    QSqlQuery query;

    if (query.exec(QObject::tr("delete from SLCD_T_Package where 1")))
    {
        return true;
    } else {
        return false;
    }
}
